home *** CD-ROM | disk | FTP | other *** search
/ User's Choice Windows CD / User's Choice Windows CD (CMS Software)(1993).iso / utility1 / gs261src.zip / SCFD.C < prev    next >
C/C++ Source or Header  |  1993-05-19  |  18KB  |  613 lines
  1. /* Copyright (C) 1992, 1993 Aladdin Enterprises.  All rights reserved.
  2.  
  3. This file is part of Ghostscript.
  4.  
  5. Ghostscript is distributed in the hope that it will be useful, but
  6. WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
  7. to anyone for the consequences of using it or for whether it serves any
  8. particular purpose or works at all, unless he says so in writing.  Refer
  9. to the Ghostscript General Public License for full details.
  10.  
  11. Everyone is granted permission to copy, modify and redistribute
  12. Ghostscript, but only under the conditions described in the Ghostscript
  13. General Public License.  A copy of this license is supposed to have been
  14. given to you along with Ghostscript so you can know your rights and
  15. responsibilities.  It should be in a file named COPYING.  Among other
  16. things, the copyright notice and this notice must be preserved on all
  17. copies.  */
  18.  
  19. /* scfd.c */
  20. /* CCITTFax decoding filter */
  21. #include "stdio_.h"    /* includes std.h */
  22. #include "memory_.h"
  23. #include "gdebug.h"
  24. #include "scf.h"
  25. #include "stream.h"
  26. #include "sbits.h"
  27.  
  28. /* Initialize CCITTFaxDecode filter */
  29. void
  30. s_CFD_init(register stream *s, CCITTFax_state *pcfs)
  31. {    int raster = pcfs->raster;    /* s->state.cf isn't set yet! */
  32.     s->state.cf = *pcfs;
  33.     if ( s->state.cf.K != 0 )
  34.     {    /* Clear the initial reference line for 2-D encoding. */
  35.         s->cptr = s->endptr = s->cbuf + raster * 3 - 1;
  36.         s->state.cf.prev_pos = raster * 2;
  37.         memset(s->cbuf + raster * 2, (s->state.cf.BlackIs1 ? 0 : 0xff),
  38.                raster);
  39.     }
  40.     s->state.cf.k_left = min(s->state.cf.K, 0);
  41.     s->state.cf.cbit = 0;
  42.     s->state.cf.uncomp_run = 0;
  43.     s->state.cf.rows_left =
  44.         (s->state.cf.Rows <= 0 ? -1 : s->state.cf.Rows);
  45.     sgetbits_init(s, s->state.cf.FirstBitLowOrder);
  46. }
  47.  
  48. /* Declare the variables that hold the state of the input. */
  49. #define cfd_declare_stream_state\
  50.     stream *strm = s->strm;\
  51.     register byte *inptr;\
  52.     byte *inend
  53. #define cfd_declare_state\
  54.     cfd_declare_stream_state;\
  55.     register byte *p;\
  56.     int pbit;\
  57.     uint bits;\
  58.     int bits_left
  59. /* Load the input state from the stream. */
  60. #define cfd_load_stream_state()\
  61.     inptr = sbufptr(strm), inend = sbufend(strm)
  62. #define cfd_load_state()\
  63.     cfd_load_stream_state(),\
  64.     p = s->cptr, pbit = s->state.cf.cbit,\
  65.     bits = s->bits, bits_left = s->bits_left
  66. /* Store the input state back in the stream. */
  67. #define cfd_store_stream_state()\
  68.     ssetbufptr(strm, inptr)
  69. #define cfd_store_state()\
  70.     cfd_store_stream_state(),\
  71.     s->cptr = p, s->state.cf.cbit = pbit,\
  72.     s->bits = bits, s->bits_left = bits_left
  73.  
  74. /* Macros to get blocks of bits from the input stream. */
  75. /* Invariants: 0 <= bits_left <= bits_size; */
  76. /* bits [bits_left-1..0] contain valid data. */
  77. #define bits_size (arch_sizeof_int * 8) /* avoid sizeof so is constant */
  78. /* n must not be greater than 8. */
  79. #define ensure_bits(n)\
  80.   if ( bits_left < n ) more_bits()
  81. #define more_bits_1()\
  82.   { int c;\
  83.     if ( inptr < inend ) c = *inptr++;\
  84.     else { cfd_store_stream_state(); c = sgetc(strm); cfd_load_stream_state(); }\
  85.     if ( c < 0 ) { s->end_status = c; goto out; }\
  86.     if ( s->reverse_bits ) c = sbits_reverse_bits[c];\
  87.     bits = (bits << 8) + c, bits_left += 8;\
  88.   }
  89. #if bits_size == 16
  90. #  define more_bits() more_bits_1()
  91. #else                /* bits_size >= 32 */
  92. #  define more_bits()\
  93.   { if ( inend - inptr < 3 ) more_bits_1()\
  94.     else\
  95.     { if ( s->reverse_bits )\
  96.     bits = (bits << 24) + ((uint)sbits_reverse_bits[*inptr] << 16) + ((uint)sbits_reverse_bits[inptr[1]] << 8) + sbits_reverse_bits[inptr[2]];\
  97.       else\
  98.     bits = (bits << 24) + ((uint)*inptr << 16) + ((uint)inptr[1] << 8) + inptr[2];\
  99.       bits_left += 24, inptr += 3;\
  100.     }\
  101.   }
  102. #endif
  103. #define peek_bits(n) ((bits >> (bits_left - (n))) & ((1 << (n)) - 1))
  104. #define peek_var_bits(n) ((bits >> (bits_left - (n))) & peek_masks[n])
  105. static const byte peek_masks[9] = { 0, 1, 3, 7, 0xf, 0x1f, 0x3f, 0x7f, 0xff };
  106. #define skip_bits(n) bits_left -= (n)
  107.  
  108. /* Get a run from the stream. */
  109. #define get_run(decode, initial_bits, runlen, str)\
  110. {    const cfd_node *np;\
  111.     int clen;\
  112.     ensure_bits(initial_bits);\
  113.     np = &decode[peek_bits(initial_bits)];\
  114.     if ( (clen = np->code_length) > initial_bits )\
  115.     {    do_debug(uint init_bits = peek_bits(initial_bits));\
  116.         clen -= initial_bits;\
  117.         skip_bits(initial_bits);\
  118.         ensure_bits(clen);\
  119.         np = &decode[np->run_length + peek_var_bits(clen)];\
  120.         if_debug4('W', "%s clen=%d xcode=0x%x rlen=%d\n", str,\
  121.               initial_bits + np->code_length,\
  122.               (init_bits << np->code_length) +\
  123.                   peek_var_bits(np->code_length),\
  124.               np->run_length);\
  125.         skip_bits(np->code_length);\
  126.     }\
  127.     else\
  128.     {    if_debug4('W', "%s clen=%d code=0x%x rlen=%d\n", str,\
  129.               clen, peek_var_bits(clen), np->run_length);\
  130.         skip_bits(clen);\
  131.     }\
  132.     runlen = np->run_length;\
  133. }
  134.  
  135. /* Skip data bits for a white run. */
  136. /* rlen is either less than 64, or a multiple of 64. */
  137. #define skip_data(rlen, makeup_label)\
  138.     if ( (pbit -= rlen) < 0 )\
  139.     {    p -= pbit >> 3, pbit &= 7;\
  140.         if ( rlen >= 64 ) goto makeup_label;\
  141.     }
  142.  
  143. /* Invert data bits for a black run. */
  144. /* If rlen >= 64, execute makeup_action: this is to handle */
  145. /* makeup codes efficiently, since these are always a multiple of 64. */
  146. #define invert_data(rlen, black_byte, makeup_action, d)\
  147.     if ( rlen > pbit )\
  148.     {    *p++ ^= (1 << pbit) - 1;\
  149.         rlen -= pbit;\
  150.         switch ( rlen >> 3 )\
  151.         {\
  152.         default:    /* original rlen >= 64 */\
  153. d:            memset(p, black_byte, rlen >> 3);\
  154.             p += rlen >> 3;\
  155.             rlen &= 7;\
  156.             if ( !rlen ) pbit = 0, p--;\
  157.             else pbit = 8 - rlen, *p ^= 0xff << pbit;\
  158.             makeup_action;\
  159.             break;\
  160.         case 7:        /* original rlen possibly >= 64 */\
  161.             if ( rlen + pbit >= 64 ) goto d;\
  162.             *p++ = black_byte;\
  163.         case 6: *p++ = black_byte;\
  164.         case 5: *p++ = black_byte;\
  165.         case 4: *p++ = black_byte;\
  166.         case 3: *p++ = black_byte;\
  167.         case 2: *p++ = black_byte;\
  168.         case 1: *p = black_byte;\
  169.             rlen &= 7;\
  170.             if ( !rlen ) { pbit = 0; break; }\
  171.             p++;\
  172.         case 0:            /* know rlen != 0 */\
  173.             pbit = 8 - rlen;\
  174.             *p ^= 0xff << pbit;\
  175.         }\
  176.     }\
  177.     else\
  178.         pbit -= rlen,\
  179.         *p ^= ((1 << rlen) - 1) << pbit
  180.  
  181. /* Buffer refill for CCITTFaxDecode filter */
  182. private int cf_decode_1d(P1(stream *));
  183. private int cf_decode_2d(P2(stream *, byte *));
  184. private int cf_decode_uncompressed(P1(stream *));
  185. private int
  186. s_CFD_read_buf(register stream *s)
  187. {    cfd_declare_stream_state;
  188.     int raster = s->state.cf.raster;
  189.     register byte *p = s->cbuf - 1;
  190.     byte *prev = p + s->state.cf.prev_pos;
  191.     byte *limit = p + s->bsize;
  192.     int k_left = s->state.cf.k_left;
  193.     int rows_left = s->state.cf.rows_left;
  194.     uint bits;
  195.     int bits_left;
  196.     cfd_load_stream_state();
  197.     bits = s->bits;
  198.     bits_left = s->bits_left;
  199.     /* Do complete scan lines. */
  200.     while ( limit - p > raster && rows_left != 0 )    /* need 1 extra byte for 2-D */
  201.     {    int code;
  202.         int eol_count = 0;
  203.         if ( s->state.cf.EncodedByteAlign )
  204.             bits_left &= ~7;
  205.         for ( ; ; )
  206.         {    /* Check for (an) initial EOL code(s). */
  207.             /* In 16-bit environments, we can't look at the */
  208.             /* entire EOL code simultaneously; having two */
  209.             /* separate algorithms isn't worth the trouble. */
  210.             ensure_bits(8);
  211.             /* Read an extra byte, and put it back if needed. */
  212.             if ( peek_bits(8) != 0 )
  213.                 break;
  214.             skip_bits(8);
  215.             more_bits_1();
  216.             if ( peek_bits(run_eol_code_length-9) != 0 )
  217.             {    /* Undo the more_bits_1() */
  218.                 bits >>= 8;
  219.                 bits_left -= 8;
  220.                 inptr--;    /*sputback(strm)*/
  221.                 break;
  222.             }
  223.             /* Skip over padding and EOL. */
  224.             while ( 1 )
  225.             {    ensure_bits(1);
  226.                 if ( peek_bits(1) )
  227.                     break;
  228.                 skip_bits(1);
  229.             }
  230.             skip_bits(1);
  231.             if_debug0('w', "[w]EOL\n");
  232.             /* If we are in a Group 3 mixed regime, */
  233.             /* check the next bit for 1- vs. 2-D. */
  234.             if ( s->state.cf.K > 0 )
  235.             {    ensure_bits(1);
  236.                 k_left = (peek_bits(1) ? 0 : 1);
  237.                 skip_bits(1);
  238.             }
  239.             ++eol_count;
  240.             if ( s->state.cf.EndOfBlock )
  241.             {    /* Check for end-of-data sequence. */
  242.                 if (eol_count == (s->state.cf.K < 0 ? 2 : 6))
  243.                 {    s->end_status = EOFC;
  244.                     goto out;
  245.                 }
  246.             }
  247.             else
  248.                 break;        /* >1 EOL is an error */
  249.         }
  250.         switch ( eol_count )
  251.         {
  252.         case 0:
  253.             if ( s->state.cf.EndOfLine )
  254.             {    /* EOL is required, but none is present. */
  255.                 s->end_status = ERRC;
  256.                 break;
  257.             }
  258.         case 1:
  259.             break;
  260.         default:
  261.             s->end_status = ERRC;
  262.             goto out;
  263.         }
  264.         s->cptr = p;
  265.         s->state.cf.cbit = 0;        /* for now */
  266.         s->bits = bits;
  267.         s->bits_left = bits_left;
  268.         cfd_store_stream_state();
  269.         if ( k_left < 0 )
  270.         {    if_debug0('w', "[w2]new row\n");
  271.             code = cf_decode_2d(s, prev);
  272.         }
  273.         else if ( k_left == 0 )
  274.         {    if_debug0('w', "[w1]new row\n");
  275.             code = cf_decode_1d(s);
  276.             k_left = s->state.cf.K;
  277.         }
  278.         else
  279.         {    if_debug1('w', "[w1]new 2-D row, %d left\n", k_left);
  280.             code = cf_decode_2d(s, prev);
  281.             k_left--;
  282.         }
  283.         cfd_load_stream_state();
  284.         bits = s->bits;
  285.         bits_left = s->bits_left;
  286.         if ( code < 0 )
  287.         {    s->end_status = ERRC;
  288.             break;
  289.         }
  290.         prev = p;
  291.         p += raster;
  292.         if ( rows_left >= 0 ) rows_left--;
  293.     }
  294.     if ( rows_left == 0 )
  295.         s->end_status = EOFC;
  296. out:    cfd_store_stream_state();
  297.     s->bits = bits;
  298.     s->bits_left = bits_left;
  299.     s->cptr = s->cbuf - 1;
  300.     s->endptr = p;
  301.     s->state.cf.k_left = k_left;
  302.     s->state.cf.prev_pos = prev - s->cptr;
  303.     s->state.cf.rows_left = rows_left;
  304.     return 0;
  305. }
  306. /* Decode a 1-D scan line. */
  307. private int
  308. cf_decode_1d(stream *s)
  309. {    cfd_declare_state;
  310.     byte black_byte = (s->state.cf.BlackIs1 ? 0xff : 0);
  311.     int end_bit = -s->state.cf.Columns & 7;
  312.     int raster = s->state.cf.raster;
  313.     byte *stop;
  314.     cfd_load_state();
  315.     stop = p + raster;
  316. #define p_at_stop() (p >= stop && (pbit <= end_bit || p > stop))
  317.     memset(p + 1, ~black_byte, raster);
  318.     while ( !p_at_stop() )
  319.     {    int bcnt;
  320. dw:        /* Decode a white run. */
  321.         get_run(cf_white_decode, cfd_white_initial_bits, bcnt, "[w1]white");
  322.         if ( bcnt < 0 )
  323.                 /* exceptional situation */
  324.           switch ( bcnt )
  325.         {
  326.         case run_uncompressed:    /* Uncompressed data. */
  327.             cfd_store_state();
  328.             bcnt = cf_decode_uncompressed(s);
  329.             if ( bcnt < 0 )
  330.             {    s->end_status = bcnt;
  331.                 goto out;
  332.             }
  333.             cfd_load_state();
  334.             if ( bcnt ) goto db;
  335.             else goto dw;
  336.         /*case run_error:*/
  337.         /*case run_zeros:*/    /* Premature end-of-line. */
  338.         default:
  339.             s->end_status = ERRC;
  340.             goto out;
  341.         }
  342.         skip_data(bcnt, dw);
  343.         if ( p_at_stop() ) break;
  344. db:        /* Decode a black run. */
  345.         get_run(cf_black_decode, cfd_black_initial_bits, bcnt, "[w1]black");
  346.         if ( bcnt < 0 )
  347.         {    /* All exceptional codes are invalid here. */
  348.             /****** WRONG, uncompressed IS ALLOWED ******/
  349.             s->end_status = ERRC;
  350.             goto out;
  351.         }
  352.         /* Invert bits designated by black run. */
  353.         invert_data(bcnt, black_byte, goto db, idb);
  354.     }
  355.     if ( p > stop || pbit < end_bit )
  356.     {    s->end_status = ERRC;
  357.         goto out;
  358.     }
  359. out:    cfd_store_state();
  360.     return s->end_status;
  361. }
  362. /* Decode a 2-D scan line. */
  363. private int
  364. cf_decode_2d(stream *s, byte *prev_p)
  365. {    cfd_declare_state;
  366.     int dist;
  367.     byte invert = (s->state.cf.BlackIs1 ? 0 : 0xff);
  368.     byte black_byte = ~invert;
  369.     byte invert_white = invert;
  370.     register int count;
  371.     int end_count = -s->state.cf.Columns & 7;
  372.     uint raster = s->state.cf.raster;
  373.     byte *endptr;
  374.     int init_count = raster << 3;
  375.     int rlen;
  376.     cfd_load_state();
  377.     endptr = p + raster;
  378.     memset(p + 1, invert, raster);
  379.     endptr[1] = 0xa0;    /* a byte with some 0s and some 1s, */
  380.                 /* to ensure run scan will stop */
  381.     dist = prev_p - p;
  382.     if_debug2('W', "[w2]raster=%d dist=%d\n", raster, dist);
  383.     for ( count = init_count; count > end_count; )
  384.     {    /* If invert == invert_white, white and black have their */
  385.         /* correct meanings; if invert == ~invert_white, */
  386.         /* black and white are interchanged. */
  387.         if_debug1('W', "[w2]%4d:\n", count);
  388. #ifdef DEBUG
  389.         /* Check the invariant between p, pbit, and count. */
  390.         {    int pcount = (endptr - p) * 8 + pbit;
  391.             if ( pcount != count )
  392.                 dprintf2("[w2]Error: count=%d pcount=%d\n",
  393.                      count, pcount);
  394.         }
  395. #endif
  396.         /* We could just use get_run here, but we can do better: */
  397.         ensure_bits(3);
  398.         switch( peek_bits(3) )
  399.         {
  400.         default/*4..7*/:            /* vertical(0) */
  401.             skip_bits(1);
  402.             rlen = countof(cf2_run_vertical) / 2;
  403.             break;
  404.         case 2:                    /* vertical(+1) */
  405.             skip_bits(3);
  406.             rlen = countof(cf2_run_vertical) / 2 + 1;
  407.             break;
  408.         case 3:                    /* vertical(-1) */
  409.             skip_bits(3);
  410.             rlen = countof(cf2_run_vertical) / 2 - 1;
  411.             break;
  412.         case 1:                    /* horizontal */
  413.             skip_bits(3);
  414.             if ( invert == invert_white )
  415.             {    /* White, then black. */
  416.                 int olen;
  417. hww:                get_run(cf_white_decode,
  418.                     cfd_white_initial_bits, rlen,
  419.                     " white");
  420.                 if ( (count -= rlen) < end_count )
  421.                 {    s->end_status = ERRC;
  422.                     goto out;
  423.                 }
  424.                 skip_data(rlen, hww);
  425. hwb:                get_run(cf_black_decode,
  426.                     cfd_black_initial_bits, olen,
  427.                     " black");
  428.                 if ( (count -= olen) < end_count )
  429.                 {    s->end_status = ERRC;
  430.                     goto out;
  431.                 }
  432.                 invert_data(olen, black_byte, goto hwb, ihwb);
  433.             }
  434.             else
  435.             {    /* Black, then white. */
  436.                 int olen;
  437. hbb:                get_run(cf_black_decode,
  438.                     cfd_black_initial_bits, rlen,
  439.                     " black");
  440.                 if ( (count -= rlen) < end_count )
  441.                 {    s->end_status = ERRC;
  442.                     goto out;
  443.                 }
  444.                 invert_data(rlen, black_byte, goto hbb, ihbb);
  445. hbw:                get_run(cf_white_decode,
  446.                     cfd_white_initial_bits, olen,
  447.                     " white");
  448.                 if ( (count -= olen) < end_count )
  449.                 {    s->end_status = ERRC;
  450.                     goto out;
  451.                 }
  452.                 skip_data(olen, hbw);
  453.             }
  454.             continue;
  455.         case 0:                /* everything else */
  456.             get_run(cf_2d_decode, cfd_2d_initial_bits, rlen,
  457.                 "[w2]");
  458.             /* rlen may be run2_pass, run_uncompressed, or */
  459.             /* 0..countof(cf2_run_vertical)-1. */
  460.             if ( rlen < 0 )
  461.               switch ( rlen )
  462.             {
  463.             case run2_pass:
  464.                 break;
  465.             case run_uncompressed:
  466.             {    int which;
  467.                 cfd_store_state();
  468.                 which = cf_decode_uncompressed(s);
  469.                 if ( which < 0 )
  470.                 {    s->end_status = which;
  471.                     goto out;
  472.                 }
  473.                 cfd_load_state();
  474.                 /****** ADJUST count ******/
  475.                 invert = (which ? ~invert_white : invert_white);
  476.             }    continue;
  477.             default:    /* run_error, run_zeros */
  478.                 s->end_status = ERRC;
  479.                 goto out;
  480.             }
  481.         }
  482.         /* Interpreting the run requires scanning the */
  483.         /* previous ('reference') line. */
  484.         {    int prev_count = count;
  485.             byte prev_data;
  486.             int dlen;
  487.             static const byte count_bit[8] =
  488.                 { 0x80, 1, 2, 4, 8, 0x10, 0x20, 0x40 };
  489.             prev_p = p + dist + 1;
  490.             if ( !(count & 7) )
  491.                 prev_p++;    /* because of skip macros */
  492.             prev_data = prev_p[-1] ^ invert;
  493.             /* Find the b1 transition. */
  494.             if ( (prev_data & count_bit[prev_count & 7]) &&
  495.                  (prev_count < init_count || invert != invert_white )
  496.                )
  497.             {    /* Look for changing white first. */
  498.                 if_debug1('W', " data=0x%x", prev_data);
  499.                 skip_black_pixels(prev_data, prev_p,
  500.                           prev_count, invert,
  501.                           b01, b11);
  502.                 if ( prev_count < end_count ) /* overshot */
  503.                     prev_count = end_count;
  504.                 if_debug1('W', " b1 other=%d", prev_count);
  505.             }
  506.             if ( prev_count != end_count )
  507.             {    if_debug1('W', " data=0x%x", prev_data);
  508.                 skip_white_pixels(prev_data, prev_p,
  509.                           prev_count, invert, w01);
  510.                 if ( prev_count < end_count ) /* overshot */
  511.                     prev_count = end_count;
  512.                 if_debug1('W', " b1 same=%d", prev_count);
  513.             }
  514.             /* b1 = prev_count; */
  515.             if ( rlen == run2_pass )
  516.             {    /* Pass mode.  Find b2. */
  517.                 if ( prev_count != end_count )
  518.                 {    if_debug1('W', " data=0x%x", prev_data);
  519.                     skip_black_pixels(prev_data, prev_p,
  520.                               prev_count, invert,
  521.                               b02, b12);
  522.                     if ( prev_count < end_count ) /* overshot */
  523.                         prev_count = end_count;
  524.                 }
  525.                 /* b2 = prev_count; */
  526.                 if_debug2('W', " b2=%d, pass %d\n",
  527.                       prev_count, count - prev_count);
  528.             }
  529.             else
  530.             {    /* Vertical coding. */
  531.                 /* Remember that count counts *down*. */
  532.                 prev_count += rlen - 3;    /* a1 */
  533.                 if_debug2('W', " vertical %d -> %d\n",
  534.                       3 - rlen, prev_count);
  535.             }
  536.             /* Now either invert or skip from count */
  537.             /* to prev_count, and reset count. */
  538.             if ( invert == invert_white )
  539.             {    /* Skip data bits. */
  540.                 p = endptr - (prev_count >> 3);
  541.                 pbit = prev_count & 7;
  542.             }
  543.             else
  544.             {    /* Invert data bits. */
  545.                 dlen = count - prev_count;
  546.                 invert_data(dlen, black_byte, 0, idd);
  547.             }
  548.             count = prev_count;
  549.             if ( rlen >= 0 )    /* vertical mode */
  550.                 invert = ~invert;    /* polarity changes */
  551.         }
  552.     }
  553.     if ( count < end_count )    /* overrun! */
  554.         s->end_status = ERRC;
  555. out:    cfd_store_state();
  556.     return s->end_status;
  557. }
  558. /* Decode uncompressed data. */
  559. /* (Not tested: no sample data available!) */
  560. /****** DOESN'T CHECK FOR OVERFLOWING SCAN LINE ******/
  561. private int
  562. cf_decode_uncompressed(stream *s)
  563. {    cfd_declare_state;
  564.     const cfd_node *np;
  565.     int clen, rlen;
  566.     cfd_load_state();
  567.     while ( 1 )
  568.     {    ensure_bits(cfd_uncompressed_initial_bits);
  569.         np = &cf_uncompressed_decode[peek_bits(cfd_uncompressed_initial_bits)];
  570.         clen = np->code_length;
  571.         rlen = np->run_length;
  572.         if ( clen > cfd_uncompressed_initial_bits )
  573.         {    /* Must be an exit code. */
  574.             break;
  575.         }
  576.         if ( rlen == cfd_uncompressed_initial_bits )
  577.         {    /* Longest representable white run */
  578.             if_debug1('W', "[wu]%d\n", rlen);
  579.             if ( (pbit -= cfd_uncompressed_initial_bits) < 0 )
  580.                 pbit += 8, p++;
  581.         }
  582.         else
  583.         {    if_debug1('W', "[wu]%d+1\n", rlen);
  584.             if ( pbit -= rlen < 0 )
  585.                 pbit += 8, p++;
  586.             *p ^= 1 << pbit;
  587.         }
  588.         skip_bits(clen);
  589.     }
  590.     clen -= cfd_uncompressed_initial_bits;
  591.     skip_bits(cfd_uncompressed_initial_bits);
  592.     ensure_bits(clen);
  593.     np = &cf_uncompressed_decode[rlen + peek_var_bits(clen)];
  594.     rlen = np->run_length;
  595.     skip_bits(np->code_length);
  596.     if_debug1('w', "[wu]exit %d\n", rlen);
  597.     if ( rlen >= 0 )
  598.     {    /* Valid exit code, rlen = 2 * run length + next polarity */
  599.         if ( (pbit -= rlen >> 1) < 0 )
  600.             pbit += 8, p++;
  601.         rlen &= 1;
  602.     }
  603. out:        /******* WRONG ******/
  604.     cfd_store_state();
  605.     return rlen;
  606. }
  607.  
  608. /* Stream procedures */
  609. const stream_procs s_CFD_procs =
  610.    {    s_std_noavailable, NULL, s_std_read_flush, s_std_close,
  611.     s_CFD_read_buf, NULL
  612.    };
  613.